# -*- coding: latin-1 -*-

#=========================================================================================
import os
import codecs

from Code.Constantes import *
from Code.Traducir import _SP
import Code.VarGen as VarGen
import Code.Memoria as Memoria
import Code.Util as Util

import Code.TrListas as TrListas

import Code.Boxing as Boxing

import Code.GestorEntPos as GestorEntPos
import Code.GestorEntTac as GestorEntTac
import Code.GestorGM as GestorGM
import Code.Gestor60 as Gestor60
import Code.GestorMate as GestorMate
import Code.GestorBooks as GestorBooks
import Code.GestorAperturas as GestorAperturas
import Code.GestorBoxing as GestorBoxing
import Code.Tacticas as Tacticas

import Code.QT.Iconos as Iconos
import Code.QT.PantallaGM as PantallaGM
import Code.QT.PantallaBooks as PantallaBooks
import Code.QT.DatosNueva as DatosNueva
import Code.QT.QTVarios as QTVarios
import Code.QT.PantallaAperturas as PantallaAperturas
import Code.QT.PantallaNivel as PantallaNivel
import Code.QT.PantallaBMT as PantallaBMT
import Code.QT.PantallaPotencia as PantallaPotencia
import Code.QT.PantallaPuente as PantallaPuente
import Code.QT.PantallaBoxing as PantallaBoxing
import Code.QT.PantallaHorses as PantallaHorses
import Code.QT.PantallaTacticas as PantallaTacticas
import Code.QT.PantallaLearnPGN as PantallaLearnPGN

#=========================================================================================
class Entrenamientos(  ) :

    #--------------------------------------------------------------------------------------------------------------------------------
    def __init__( self, procesador ) :
        self.procesador = procesador
        self.configuracion = procesador.configuracion
        self.menu, self.dicMenu = self.creaMenu()

    # Posiciones de entrenamiento --------------------------------------------------------------------------
    def menuEntrenamiento( self, bmenu, carpeta, titulo, xopcion ) :
        carpeta = carpeta.replace( "\\", "/" )
        icoOp = Iconos.PuntoNaranja()
        icoDr = Iconos.Carpeta()
        dicTraining = TrListas.dicTraining()
        def trTraining( txt ) :
            return dicTraining.get(txt,txt)
        menuBase = None
        dicT = {}
        menuBase = None
        for root, dirs, files in os.walk(carpeta):
            r = root.replace( "\\", "/" )
            if r == carpeta :
                if files or dirs :
                    menuBase = menuT = dicT[carpeta] = bmenu.submenu( trTraining( titulo ), icoDr )
            else :
                li = r.rsplit("/",1)
                base = dicT[li[0]]
                if files or dirs :
                    menuT = dicT[r] = base.submenu(trTraining(li[1]), icoDr)
            for x in files :
                if x.lower().endswith(".fns") :
                    if xopcion :
                        xopcion( menuT, "ep_" + os.path.join(root,x), trTraining(x[:-4]), icoOp )
                    else :
                        menuT.opcion( "ep_" + os.path.join(root,x), trTraining(x[:-4]), icoOp )
        return menuBase

    #--------------------------------------------------------------------------------------------------------------------------------
    def creaMenu( self ) :
        dicMenu = {}
        menu = QTVarios.LCMenu()

        def xopcion( menu, clave, texto, icono, siDeshabilitado = False ) :
            menu.opcion( clave, texto, icono, siDeshabilitado )
            dicMenu[clave] = (clave, texto, icono, siDeshabilitado )

        # Posiciones de entrenamiento --------------------------------------------------------------------------
        # xopcion( menu, "pos_trainings", _("Training positions" ), Iconos.Carpeta() )
        # menu.separador()
        bmenu = self.menuEntrenamiento( menu, "Trainings", _("Training positions" ), xopcion )
        self.menuEntrenamiento( bmenu, self.procesador.configuracion.dirPersonalTraining, _("Personal Training"), xopcion )
        menu.separador()

        # GM ---------------------------------------------------------------------------------------------------
        xopcion( menu, "gm", _("Play like a grandmaster" ), Iconos.GranMaestro() )
        menu.separador()

        # Mate --------------------------------------------------------------------------------------------------
        menu1 = menu.submenu( _( "Training mates" ), Iconos.Mate() )
        for mate in range( 1, 5 ) :
            xopcion( menu1, "mate%d"%mate, _X(_("Mate in %1"),str(mate)), Iconos.PuntoAzul() )
            menu1.separador()
        menu.separador()

        # BMT -------------------------------------------------------------------------------------------
        xopcion( menu, "bmt", _("Find best move"), Iconos.BMT() )
        menu.separador()

        # Books ------------------------------------------------------------------------------------------------
        xopcion( menu, "polyglot", _("Training with a book"), Iconos.Libros() )
        menu.separador()

        # Aperturas --------------------------------------------------------------------------------------------
        xopcion( menu, "aperturas", _("Learn openings by repetition"), Iconos.Apertura() )
        menu.separador()

        # Nivel ------------------------------------------------------------------------------------------------
        xopcion( menu, "nivel", _("Your daily test"), Iconos.Nivel() )
        menu.separador()

        # Resistencia ------------------------------------------------------------------------------------------
        xopcion( menu, "boxing",  _("Resistance Test" ), Iconos.Resistencia() )
        menu.separador()

        # Tacticas ---------------------------------------------------------------------------------------------
        menu1 = menu.submenu( _("Learn tactics by repetition"), Iconos.Tacticas() )
        nico = Util.Rondo( "Amarillo","Naranja","Verde","Azul","Magenta" )
        def menuTacticas( tipo, carpetaBase ) :
            try :
                li = os.listdir(carpetaBase)
                for nombre in li :
                    carpeta = os.path.join(carpetaBase,nombre)
                    ini = os.path.join(carpeta,"Config.ini")
                    if os.path.isdir(carpeta) and os.path.isfile( ini ) :
                        icono = eval( "Iconos.%s()"%nico.dameUno() )
                        xopcion( menu1, "tactica|%s|%s|%s|%s"%(tipo,nombre,carpeta,ini), nombre, icono)
                        menu1.separador()
            except :
                pass

        menuTacticas( "B", "Tactics")
        menuTacticas( "P", os.path.join(self.configuracion.dirPersonalTraining,"Tactics"))
        menu.separador()

        # Principiantes ----------------------------------------------------------------------------------------
        menu1 = menu.submenu( _( "Beginner's area" ), Iconos.ZonaPrincipiantes() )
        # menu2 = menu1.submenu( _("Opponents for young players" ), Iconos.RivalesMP() )

        # x = self.iniPrincipiantes = -8

        # mp1 = Iconos.MP1()
        # mp2 = Iconos.MP2()
        # mp3 = Iconos.MP3()
        # mp4 = Iconos.MP4()
        # mp5 = Iconos.MP5()
        # mp6 = Iconos.MP6()
        # mp7 = Iconos.MP7()

        # menu3 = menu2.submenu( _("Normal mode" ), Iconos.PuntoAzul() )
        # xopcion( menu3, x, _("Monkey" ), mp1 )
        # xopcion( menu3, x-1, _("Donkey" ), mp2 )
        # xopcion( menu3, x-2, _("Bull" ), mp3 )
        # xopcion( menu3, x-3, _("Wolf" ), mp4 )
        # xopcion( menu3, x-4, _("Lion" ), mp5 )
        # xopcion( menu3, x-5, _("Rat" ), mp6 )
        # xopcion( menu3, x-6, _("Snake" ), mp7 )

        # menu2.separador()

        # menu3 = menu2.submenu( _("Time mode" ),  Iconos.MoverTiempo() )
        # icono = Iconos.PuntoVerde()
        # li =  ( _("5 minutes"), _("3 minutes"), _("1 minute"), _( "? minutes" ) )
        # for mensaje in li :
            # x -= 7

            # menu4 = menu3.submenu( mensaje,  icono )
            # xopcion( menu4, x,   _("Monkey" ), mp1 )
            # xopcion( menu4, x-1, _("Donkey" ), mp2 )
            # xopcion( menu4, x-2, _("Bull" ), mp3 )
            # xopcion( menu4, x-3, _("Wolf" ), mp4 )
            # xopcion( menu4, x-4, _("Lion" ), mp5 )
            # xopcion( menu4, x-5, _("Rat" ), mp6 )
            # xopcion( menu4, x-6, _("Snake" ), mp7 )

            # menu3.separador()

        # menu1.separador()

        menu2 = menu1.submenu( _( "Check your memory on a chessboard" ), Iconos.Memoria() )
        rival = self.procesador.configuracion.rival

        mem = Memoria.Memoria(self.procesador)

        for x in range(6) :
            cat = rival.categorias.numero(x)
            txt = cat.nombre()

            nm = mem.nivel( x )
            if nm > -1 :
                txt += " %s %d"%(_( "Level" ), nm+1)

            icono = eval( "Iconos.%s()"%cat.color )

            xopcion( menu2, -100-x, txt, icono, siDeshabilitado = not mem.siActiva(x) )

        menu1.separador()

        menu2 = menu1.submenu( _( "Find all moves" ), Iconos.J60() )
        xopcion( menu2, "j60_rival", _("Opponent" ), Iconos.PuntoNaranja() )
        xopcion( menu2, "j60_jugador",  _("Player" ), Iconos.PuntoAzul() )

        # Cebras ---------------------------------------------------------------------------------------------------
        menu.separador()
        menu1 = menu.submenu( _("Resources for zebras" ), Iconos.Cebra() )
        xopcion( menu1, "potencia", _("Determine your calculating power" ), Iconos.Potencia() )
        menu1.separador()
        menu2 = menu1.submenu( _("Moves between two positions" ), Iconos.Puente() )
        di = (Iconos.PuntoNaranja(),Iconos.PuntoVerde(), Iconos.PuntoAzul(), Iconos.PuntoRojo(), Iconos.PuntoEstrella())
        for x in range( 1, 6 ) :
            xopcion( menu2, "puente_%d"%x, "%s %d"%(_("Level"),x), di[x-1] )

        menu1.separador()
        self.horsesDef= hd = {
                            1: ( "N", "Alpha", _("Basic test" ) ),
                            2: ( "p", "Fantasy", _("Four pawns test" ) ),
                            3: ( "Q", "Pirat", _("Jonathan Levitt test" ) ),
                            4: ( "n", "Spatial", _("Basic test" )+": a1" ),
                            5: ( "N", "NikNak", _("Basic test" )+": e4" )
                        }
        menu2 = menu1.submenu( _("Becoming a knight tamer" ), self.procesador.tablero.piezas.icono("N") )
        vicon = VarGen.todasPiezas.icono
        icl, icn, tit = hd[1]
        menu3 = menu2.submenu( tit, vicon( icl, icn ) )
        xopcion( menu3, "horses_1", tit, vicon( icl, icn ) )
        menu3.separador()
        icl, icn, tit = hd[4]
        xopcion( menu3, "horses_4", tit, vicon( icl, icn ) )
        menu3.separador()
        icl, icn, tit = hd[5]
        xopcion( menu3, "horses_5", tit, vicon( icl, icn ) )
        menu2.separador()
        icl, icn, tit = hd[2]
        xopcion( menu2, "horses_2", tit, vicon( icl, icn ) )
        menu2.separador()
        icl, icn, tit = hd[3]
        xopcion( menu2, "horses_3", tit, vicon( icl, icn ) )

        menu1.separador()
        xopcion( menu1, "learnPGN", _("Learn a game" ), Iconos.PGN() )

        menu.separador()

        return menu, dicMenu

    #--------------------------------------------------------------------------------------------------------------------------------
    def menuFavoritos( self, liFavoritos ) :

        menu = QTVarios.LCMenu()

        for clave, texto, icono, siDeshabilitado in liFavoritos :
            menu.opcion( clave, texto, icono, siDeshabilitado )
            menu.separador()

        menu.opcion( "menu_global", _( "Training" ), Iconos.Entrenamiento() )

        return menu

    #--------------------------------------------------------------------------------------------------------------------------------
    def comprueba( self ) :
        if self.menu is None :
            self.menu, self.dicMenu = self.creaMenu()

    #--------------------------------------------------------------------------------------------------------------------------------
    def rehaz( self ) :
        self.menu, self.dicMenu = self.creaMenu()

    #--------------------------------------------------------------------------------------------------------------------------------
    def lanza( self, siFavoritos = True ) :

        self.comprueba()

        liFavoritos = None
        if siFavoritos :
            liFav = self.procesador.configuracion.liFavoritos
            if liFav :
                li = []
                for elem in liFav :
                    if elem in self.dicMenu :
                        li.append( self.dicMenu[elem] )
                liFavoritos = li

        if liFavoritos :
            menu = self.menuFavoritos(liFavoritos)
        else :
            menu = self.menu

        resp = menu.lanza()

        if resp :
            siStr = type(resp) == type("")
            if siStr :
                if resp == "menu_global" :
                    self.lanza( False )

                elif resp == "gm" :
                    self.entrenaGM()

                elif resp.startswith( "mate" ) :
                    self.jugarMate(int(resp[-1]))

                elif resp == "bmt" :
                    self.bmt()

                elif resp == "polyglot" :
                    self.entrenaBooks()

                elif resp == "boxing" :
                    self.boxing()

                elif resp in ["j60_rival", "j60_jugador"] :
                    self.jugar60( resp == "j60_jugador" )

                elif resp == "aperturas" :
                    self.aperturas()

                elif resp == "nivel" :
                    self.nivelAjedrez()

                elif resp == "potencia" :
                    self.potencia()

                elif resp.startswith( "tactica|" ) :
                    nada,tipo, nombre,carpeta,ini = resp.split("|")
                    self.tacticas( tipo, nombre,carpeta,ini )

                elif resp.startswith( "puente_" ) :
                    self.puente(int(resp[7]))

                elif resp.startswith( "horses_" ) :
                    test = int(resp[7])
                    icl, icn, tit = self.horsesDef[test]
                    icon = VarGen.todasPiezas.icono(icl,icn)
                    self.horses(test,tit,icon)

                elif resp.startswith( "ep_" ) :
                    entreno = resp[3:].replace("\\", "/" )
                    if "/" in entreno :
                        dicTraining = TrListas.dicTraining()
                        titentreno = ""
                        for x in entreno[:-4].split("/")[1:] :
                            titentreno += dicTraining.get(x,x) + "/"
                        titentreno = titentreno[:-1]
                    f = codecs.open(entreno, "r",'utf-8','ignore')
                    todo = f.read().strip()
                    f.close()
                    liEntrenamientos = todo.split("\n")
                    nPosiciones = len(liEntrenamientos)
                    if nPosiciones == 0 :
                        return
                    elif nPosiciones == 1 :
                        pos = 1
                    else :
                        db = Util.DicDisk(self.configuracion.ficheroTrainings)
                        posUltimo = db[entreno]
                        if posUltimo is None :
                            posUltimo = 1
                        pos = DatosNueva.numEntrenamiento( self.procesador.pantalla, titentreno, nPosiciones, pos=posUltimo )
                        if pos is None :
                            return
                        db.close()
                    self.entrenaPos( pos, nPosiciones, titentreno, liEntrenamientos, entreno )

                elif resp == "learnPGN" :
                    self.learnPGN()

            else :
                if resp <= -100 :
                    self.menu = None # ya que puede cambiar y la etiqueta es diferente
                    mem = Memoria.Memoria(self.procesador)
                    mem.lanza( abs(resp)-100 )

                # elif resp <= self.iniPrincipiantes :
                    # lis = ( ( kMP_1, False ),
                            # ( kMP_2, False ),
                            # ( kMP_3, False ),
                            # ( kMP_4, False ),
                            # ( kMP_5, False ),
                            # ( kMP_6, True ),
                            # ( kMP_7, True ) )
                    # pos = abs(resp) + self.iniPrincipiantes
                    # siTiempo = pos >= 7
                    # segundos = 0
                    # if siTiempo :
                        # posminutos = int(pos/7)-1
                        # pos = pos%7
                        # minutos = [5,3,1,0][posminutos]
                        # if minutos == 0 :
                            # resp = QTVarios.tiempo( self.procesador.pantalla )
                            # if resp is None:
                                # return
                            # minutos, segundos = resp
                    # else :
                        # minutos = 0
                    # quien, siApertura = lis[pos]
                    # if not siTiempo :
                        # minutos = 0
                    # self.entrenaRivalesMP( quien, siApertura, minutos, segundos )

    #-----------------------------------------------------------------------------------
    def entrenaPos( self, posicion, nPosiciones, titentreno, liEntrenamientos, entreno ) :
        self.procesador.tipoJuego = kJugEntPos
        self.procesador.estado = kJugando
        self.procesador.gestor = GestorEntPos.GestorEntPos( self.procesador )
        self.procesador.gestor.ponEntreno( entreno )
        self.procesador.gestor.inicio( posicion, nPosiciones, titentreno, liEntrenamientos )

    #--------------------------------------------------------------------------------------------------------------------------------
    def tacticas( self, tipo, nombre, carpeta, ini ) :

        tacticas = Tacticas.Tacticas(tipo, nombre, carpeta, ini)
        liMenus = tacticas.listaMenus()
        if len(liMenus) == 0 :
            return

        nico = Util.Rondo( "PuntoAmarillo","PuntoNaranja","PuntoVerde","PuntoAzul","PuntoMagenta","PuntoRojo","PuntoNegro" )
        if len(liMenus) > 1 :
            menu = QTVarios.LCMenu()
            menu.opcion( None, nombre, Iconos.Tacticas() )
            menu.separador()

            dmenu = {}

            for valor, lista in liMenus :
                actmenu = menu
                if len(lista) > 1 :
                    t = ""
                    for x in range(len(lista)-1) :
                        t += "|%s"%lista[x]
                        if t not in dmenu :
                            dmenu[t] = actmenu.submenu( _SP(lista[x]), eval( "Iconos.%s()"%nico.dameUno() ) )
                            actmenu.separador()
                        actmenu = dmenu[t]
                actmenu.opcion( valor, _SP(lista[-1]), eval( "Iconos.%s()"%nico.dameUno() ) )
                actmenu.separador()
            resp = menu.lanza()

        else :
            resp = liMenus[0][0]

        if not resp :
            return

        tactica = tacticas.eligeTactica(resp)

        if tactica :
            self.entrenaTactica( tactica )

    #--------------------------------------------------------------------------------------------------------------------------------
    def entrenaTactica( self, tactica ) :
        tactica.leeDatos( self.configuracion.carpeta )
        icono = Iconos.PuntoMagenta()
        resp = PantallaTacticas.consultaHistorico(self.procesador.pantalla, tactica, icono )
        if resp :
            if resp != "seguir" :
                if resp != "auto" :
                    if resp.startswith( "copia" ) :
                        ncopia = int(resp[5:])
                    else :
                        ncopia = None
                    if not PantallaTacticas.edita1tactica( self.procesador.pantalla, tactica, ncopia ) :
                        return
                um = self.procesador.unMomento()
                tactica.genera()
                um.final()
            self.procesador.tipoJuego = kJugEntTac
            self.procesador.estado = kJugando
            self.procesador.gestor = GestorEntTac.GestorEntTac( self.procesador )
            self.procesador.gestor.inicio( tactica )

    #--------------------------------------------------------------------------------------------------------------------------------
    def entrenaRivalesMP( self, rival, siApertura, nMinutos, nSegundos ) :

        siBlancas = QTVarios.blancasNegras( self.procesador.pantalla )
        if siBlancas is None :
            return

        self.entrenaRivalesMPC( siBlancas, rival, siApertura, nMinutos, nSegundos )

    #--------------------------------------------------------------------------------------------------------------------------------
    def entrenaRivalesMPC( self, siBlancas, rival, siApertura, nMinutos, nSegundos ) :

        dic = {}
        dic["SIBLANCAS"] = siBlancas
        dic["COLOR"] = "B" if siBlancas else "N"
        dic["FEN"] = ""
        dic["AYUDAS"] = 0
        dic["APERTURA"] = None
        dic["SIAPERTURA"] = siApertura

        dr = dic["RIVAL"] = {}
        dr["MOTOR"] = rival
        dr["TIEMPO"] = 0
        dr["PROFUNDIDAD"] = 0

        dr = dic["TUTOR"] = {}

        dr["MOTOR"] = self.procesador.configuracion.tutor.claveReal()
        dr["TIEMPO"] = self.procesador.configuracion.tiempoTutor/100
        dr["PROFUNDIDAD"] = 0

        dic["SITIEMPO"] = nMinutos > 0
        if dic["SITIEMPO"] :
            dic["MINUTOS"] = nMinutos
            dic["SEGUNDOS"] = nSegundos

        dic["ATRAS"] = True

        self.procesador.entrenaMaquina( dic )

    #--------------------------------------------------------------------------------------------------------------------------------
    def entrenaGM( self ) :
        w = PantallaGM.WGM( self.procesador )
        if w.exec_() :
            self.procesador.tipoJuego = kJugGM
            self.procesador.estado = kJugando
            self.procesador.gestor = GestorGM.GestorGM( self.procesador )
            self.procesador.gestor.inicio( w.modo, w.gm, w.siBlancas, w.siJuez, w.motor, w.tiempo, w.depth, w.multiPV, w.mostrar, w.jugContrario, w.jugInicial )

    #--------------------------------------------------------------------------------------------------------------------------------
    def entrenaBooks( self ) :
        w = PantallaBooks.WBooks( self.procesador )
        if w.exec_() and w.libro :
            self.procesador.tipoJuego = kJugBooks
            self.procesador.estado = kJugando
            self.procesador.gestor = GestorBooks.GestorBooks( self.procesador )
            self.procesador.gestor.inicio( w.libro, w.siBlancas, w.jugContrario, w.jugJugador )

    #--------------------------------------------------------------------------------------------------------------------------------
    def jugar60( self, siJugador ) :
        self.procesador.gestor = Gestor60.Gestor60( self.procesador )
        self.procesador.gestor.inicio( siJugador )

    #--------------------------------------------------------------------------------------------------------------------------------
    def jugarMate( self, tipo ) :
        self.procesador.gestor = GestorMate.GestorMate( self.procesador )
        self.procesador.gestor.inicio( tipo )

    #--------------------------------------------------------------------------------------------------------------------------------
    def aperturas( self ) :
        w = PantallaAperturas.EntrenamientoAperturas( self.procesador )
        if w.exec_() :
            listaAperturasStd, ficheroDatos, lista, fila, jugamos, repeticiones = w.resultado
            self.procesador.gestor = GestorAperturas.GestorAperturas( self.procesador )
            self.procesador.gestor.inicio( listaAperturasStd, ficheroDatos, lista, fila, jugamos, repeticiones, 0 )

    #--------------------------------------------------------------------------------------------------------------------------------
    def nivelAjedrez( self ) :
        PantallaNivel.pantallaNivel( self.procesador )

    #--------------------------------------------------------------------------------------------------------------------------------
    def potencia( self ) :
        PantallaPotencia.pantallaPotencia( self.procesador )

    #--------------------------------------------------------------------------------------------------------------------------------
    def puente( self, nivel ) :
        PantallaPuente.pantallaPuente( self.procesador, nivel )

    #--------------------------------------------------------------------------------------------------------------------------------
    def horses( self, test,titulo,icono ) :
        PantallaHorses.pantallaHorses( self.procesador, test, titulo, icono )

    #--------------------------------------------------------------------------------------------------------------------------------
    def bmt( self ) :
        PantallaBMT.pantallaBMT( self.procesador )

    #--------------------------------------------------------------------------------------------------------------------------------
    def boxing( self ) :
        boxing = Boxing.Boxing( self.procesador )
        resp = PantallaBoxing.pantallaBoxing( self.procesador.pantalla, boxing )
        if resp is not None :
            numEngine, siBlancas = resp
            self.procesador.gestor = GestorBoxing.GestorBoxing( self.procesador )
            self.procesador.gestor.inicio( boxing, numEngine, siBlancas )

    #--------------------------------------------------------------------------------------------------------------------------------
    def learnPGN( self ) :
        w = PantallaLearnPGN.WLearnBase( self.procesador )
        w.exec_()

#=========================================================================================
